
#pragma once
#include "parser_base.hpp"
#include <iostream>
#include <math.h>
#include <algorithm>
#include <vector>
#include <map>
#include <string>

#include <miliwave_msg/Func_Diag_Rx.h>

#include <miliwave_msg/ADAS_Phys_Diag_Rx.h>

#include <miliwave_msg/VCU_21_A.h>

#include <miliwave_msg/VCU_14_A.h>

#include <miliwave_msg/VCU_13_A.h>

#include <miliwave_msg/VCU_9_A.h>

#include <miliwave_msg/VCU_2_A.h>

#include <miliwave_msg/SAS_1.h>

#include <miliwave_msg/PAS_4.h>

#include <miliwave_msg/PAS_3.h>

#include <miliwave_msg/PAS_2.h>

#include <miliwave_msg/PAS_1.h>

#include <miliwave_msg/EPS_2.h>

#include <miliwave_msg/EPS_1.h>

#include <miliwave_msg/EBB_2_A.h>

#include <miliwave_msg/EBB_1_A.h>

#include <miliwave_msg/DMS_1.h>

#include <miliwave_msg/BCS_EPB_2_A.h>

#include <miliwave_msg/BCS_EPB_1_A.h>

#include <miliwave_msg/BCS_11_A.h>

#include <miliwave_msg/BCS_10_A.h>

#include <miliwave_msg/BCS_9_A.h>

#include <miliwave_msg/BCS_8_A.h>

#include <miliwave_msg/BCS_7_A.h>

#include <miliwave_msg/BCS_6_A.h>

#include <miliwave_msg/BCS_5_A.h>

#include <miliwave_msg/BCS_3_A.h>

#include <miliwave_msg/BCS_2_A.h>

#include <miliwave_msg/BSDS_1.h>

#include <miliwave_msg/BSDM_1.h>

#include <miliwave_msg/GW_SRS_2_A.h>

#include <miliwave_msg/GW_SRS_1_A.h>

#include <miliwave_msg/GW_ICM_HVAC_A.h>

#include <miliwave_msg/GW_ICM_1_A.h>

#include <miliwave_msg/GW_HOD_1_A.h>

#include <miliwave_msg/GW_BCM_RLS_1_B_A.h>

#include <miliwave_msg/GW_BCM_2_A.h>

#include <miliwave_msg/GW_BCM_1_A.h>

#include <miliwave_msg/GW_ACU_10_A_A.h>

#include <miliwave_msg/GW_ACU_3_A_A.h>

#include <miliwave_msg/GW_ACU_2_A_A.h>

#include <miliwave_msg/GW_ACU_11_A.h>

#include <miliwave_msg/GW_ACU_10_A.h>

#include <miliwave_msg/GW_ACU_2_A.h>

#include <miliwave_msg/ADAS_Diag_Tx.h>

#include <miliwave_msg/IFC_5.h>

#include <miliwave_msg/IFC_4.h>

#include <miliwave_msg/ADAS_FRR_1.h>

#include <miliwave_msg/ADAS_6_A.h>

#include <miliwave_msg/ADAS_5_A.h>

#include <miliwave_msg/ADAS_4_A.h>

#include <miliwave_msg/ADAS_3_A.h>

#include <miliwave_msg/ADAS_2_A.h>

#include <miliwave_msg/ADAS_1_A.h>

#include <miliwave_msg/MRR_3.h>

#include <miliwave_msg/MRR_2.h>

#include <miliwave_msg/MRR_1.h>

#include <miliwave_msg/MRR_IFC_2.h>

#include <miliwave_msg/MRR_IFC_1.h>

using namespace std;

class AllMsg : public ParserBase
{
public:
    void inputMsg(const msg_gen::Frame::ConstPtr &msg)
    {

        auto it = *msg;
        vector<int> value;
        int num;
        for(int i=0;i<8;i++){
            num = (int)it.data[i];
            vector<int> num_list;
            for(int j = 0;j < 8;j++){
                    num_list.push_back(num%2);
                    num = num/2;
            }
            reverse(num_list.begin(),num_list.end());
            for(int k = 0;k < 8;k++)value.push_back(num_list[k]);
        };


        std::cout << it.id << std::endl;
        switch (it.id){

            case (0x7df):{

                miliwave_msg::Func_Diag_Rx radar_list_;

                

                string signal_name_list[] = {"Func_Diag_Rx"};

                int bit_index[] = {56, 64};

                double signal_factor[] = {1.0};

                double signal_offset[] = {0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.Func_Diag_Rx = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x70e):{

                miliwave_msg::ADAS_Phys_Diag_Rx radar_list_;

                

                string signal_name_list[] = {"ADAS_Diag_Request"};

                int bit_index[] = {56, 64};

                double signal_factor[] = {1.0};

                double signal_offset[] = {0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.ADAS_Diag_Request = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x176):{

                miliwave_msg::VCU_21_A radar_list_;

                

                string signal_name_list[] = {"VCU_EMS_EngSpdVD","VCU_EMS_EngSpd","VCU_EMS_AccPedalActPst","VCU_EMS_AccPedalActPstVD","VCU_EMS_BrkPedalStVD","VCU_EMS_BrkPedalSt","VCU_21_A_MsgCounter","VCU_21_A_Checksum"};

                int bit_index[] = {11, 1, 32, 16, 40, 8, 55, 1, 54, 1, 53, 1, 48, 4, 56, 8};

                double signal_factor[] = {1.0, 1.0, 0.392, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.VCU_EMS_EngSpdVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.VCU_EMS_EngSpd = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.VCU_EMS_AccPedalActPst = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.VCU_EMS_AccPedalActPstVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.VCU_EMS_BrkPedalStVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.VCU_EMS_BrkPedalSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.VCU_21_A_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.VCU_21_A_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x370):{

                miliwave_msg::VCU_14_A radar_list_;

                

                string signal_name_list[] = {"VCU_VehWheelTorqMax","VCU_AccDriverOrvd","VCU_AccElecECFail","VCU_AccTMCFail","EMS_GasPedalActPstforMRRVD","EMS_ACCButtInfo","EMS_GasPedalActPstforMRR","VCU_14_A_MsgCounter","VCU_14_A_Checksum"};

                int bit_index[] = {10, 14, 31, 1, 30, 1, 29, 1, 27, 1, 32, 8, 40, 8, 48, 4, 56, 8};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.392, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.VCU_VehWheelTorqMax = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.VCU_AccDriverOrvd = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.VCU_AccElecECFail = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.VCU_AccTMCFail = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.EMS_GasPedalActPstforMRRVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.EMS_ACCButtInfo = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.EMS_GasPedalActPstforMRR = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.VCU_14_A_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.VCU_14_A_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x2b1):{

                miliwave_msg::VCU_13_A radar_list_;

                

                string signal_name_list[] = {"VCU_ACCMaxRecpDecel","VCU_LateralAssistBtnInfoVD","VCU_LateralAssistBtnInfo","VCU_ACCMaxRecpDecelVD","VCU_ACCLimitOperatingSt","VCU_ActVehWheelTorq","VCU_ACCmaxSpdLimit","VCU_13_A_MsgCounter","VCU_13_A_Checksum"};

                int bit_index[] = {16, 8, 28, 1, 27, 1, 26, 1, 25, 1, 42, 14, 52, 4, 48, 4, 56, 8};

                double signal_factor[] = {0.05, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {-5.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.VCU_ACCMaxRecpDecel = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.VCU_LateralAssistBtnInfoVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.VCU_LateralAssistBtnInfo = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.VCU_ACCMaxRecpDecelVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.VCU_ACCLimitOperatingSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.VCU_ActVehWheelTorq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.VCU_ACCmaxSpdLimit = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.VCU_13_A_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.VCU_13_A_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x2ab):{

                miliwave_msg::VCU_9_A radar_list_;

                

                string signal_name_list[] = {"VCU_RecpTorqVD","VCU_RecpTorq","VCU_9_A_MsgCounter","VCU_BrkPedPstVD","VCU_CrntGearLvl","VCU_CrntGearLvlVD","VCU_BrkVcuuPressVD","VCU_BrkVcuuPress","VCU_BrkPedPst","VCU_9_A_Checksum"};

                int bit_index[] = {11, 1, 16, 11, 28, 4, 27, 1, 36, 3, 35, 1, 34, 1, 40, 10, 48, 8, 56, 8};

                double signal_factor[] = {1.0, 2.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.392, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.VCU_RecpTorqVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.VCU_RecpTorq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.VCU_9_A_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.VCU_BrkPedPstVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.VCU_CrntGearLvl = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.VCU_CrntGearLvlVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.VCU_BrkVcuuPressVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.VCU_BrkVcuuPress = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.VCU_BrkPedPst = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.VCU_9_A_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x360):{

                miliwave_msg::VCU_2_A radar_list_;

                

                string signal_name_list[] = {"VCU_VehRdySt","VCU_VehDrvMod","VCU_GearLvl"};

                int bit_index[] = {22, 1, 16, 3, 44, 4};

                double signal_factor[] = {1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.VCU_VehRdySt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.VCU_VehDrvMod = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.VCU_GearLvl = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x264):{

                miliwave_msg::SAS_1 radar_list_;

                

                string signal_name_list[] = {"SAS_1_Checksum","SAS_1_MsgCounter","SAS_TrimmingStatus","SAS_CalibratedSt","SAS_SteeringAngleVD","SAS_SteeringAngleSpd","SAS_SteeringAngle"};

                int bit_index[] = {4, 4, 0, 4, 10, 1, 9, 1, 8, 1, 16, 8, 32, 16};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 4.0, 0.1};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -780.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.SAS_1_Checksum = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.SAS_1_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.SAS_TrimmingStatus = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.SAS_CalibratedSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.SAS_SteeringAngleVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.SAS_SteeringAngleSpd = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.SAS_SteeringAngle = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x163):{

                miliwave_msg::PAS_4 radar_list_;

                

                string signal_name_list[] = {"PAS_APASt"};

                int bit_index[] = {36, 3};

                double signal_factor[] = {1.0};

                double signal_offset[] = {0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.PAS_APASt = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x162):{

                miliwave_msg::PAS_3 radar_list_;

                

                string signal_name_list[] = {"PAS_Mode"};

                int bit_index[] = {40, 4};

                double signal_factor[] = {1.0};

                double signal_offset[] = {0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.PAS_Mode = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x347):{

                miliwave_msg::PAS_2 radar_list_;

                

                string signal_name_list[] = {"PAS_FRDistance","PAS_FLDistance","PAS_FRMidDistance","PAS_FLMidDistance","PAS_FSRSideDistance","PAS_FSLSideDistance"};

                int bit_index[] = {0, 8, 8, 8, 16, 8, 24, 8, 32, 8, 40, 8};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.PAS_FRDistance = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.PAS_FLDistance = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.PAS_FRMidDistance = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.PAS_FLMidDistance = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.PAS_FSRSideDistance = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.PAS_FSLSideDistance = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x343):{

                miliwave_msg::PAS_1 radar_list_;

                

                string signal_name_list[] = {"PAS_WarnTone","PAS_SysFailureFlag","PAS_SystemType","PAS_RRMidDistance","PAS_RLMidDistance","PAS_RRDistance","PAS_RLDistance","PAS_RSLSideDistance","PAS_RSRSideDistance"};

                int bit_index[] = {4, 4, 2, 2, 0, 2, 16, 8, 24, 8, 32, 8, 40, 8, 48, 8, 56, 8};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.PAS_WarnTone = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.PAS_SysFailureFlag = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.PAS_SystemType = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.PAS_RRMidDistance = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.PAS_RLMidDistance = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.PAS_RRDistance = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.PAS_RLDistance = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.PAS_RSLSideDistance = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.PAS_RSRSideDistance = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x16a):{

                miliwave_msg::EPS_2 radar_list_;

                

                string signal_name_list[] = {"EPS_LKACtrlSt","EPS_LKACtrlAbortFeedback","EPS_LKACtrlDlvdValue","EPS_LKACtrlDlvdValueVD","EPS_HandsOffDetSt","EPS_HandsOffDetStVD","EPS_AssistPraSwitchToLKA","EPS_2_MsgCounter","EPS_2_Checksum"};

                int bit_index[] = {5, 3, 12, 4, 17, 11, 16, 1, 30, 2, 29, 1, 28, 1, 48, 4, 56, 8};

                double signal_factor[] = {1.0, 1.0, 0.01, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, -10.24, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.EPS_LKACtrlSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.EPS_LKACtrlAbortFeedback = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.EPS_LKACtrlDlvdValue = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.EPS_LKACtrlDlvdValueVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.EPS_HandsOffDetSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.EPS_HandsOffDetStVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.EPS_AssistPraSwitchToLKA = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.EPS_2_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.EPS_2_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x366):{

                miliwave_msg::EPS_1 radar_list_;

                

                string signal_name_list[] = {"EPS_SteeringAngleSpdVD","EPS_1_MsgCounter","EPS_WarnLamp","EPS_StrngWhlTorqVD","EPS_SteeringAngle","EPS_SteeringAngleSpd","EPS_SteeringModeSt","EPS_SteeringAngleVD","EPS_FunctionStyleSt","EPS_StrngWhlTorq","EPS_1_Checksum"};

                int bit_index[] = {7, 1, 2, 4, 1, 1, 0, 1, 16, 16, 38, 8, 35, 2, 34, 1, 32, 2, 40, 8, 56, 8};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 0.1, 4.0, 1.0, 1.0, 1.0, 0.1, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, -780.0, 0.0, 0.0, 0.0, 0.0, -12.7, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.EPS_SteeringAngleSpdVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.EPS_1_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.EPS_WarnLamp = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.EPS_StrngWhlTorqVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.EPS_SteeringAngle = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.EPS_SteeringAngleSpd = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.EPS_SteeringModeSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.EPS_SteeringAngleVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.EPS_FunctionStyleSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.EPS_StrngWhlTorq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 10){
                        radar_list_.EPS_1_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x283):{

                miliwave_msg::EBB_2_A radar_list_;

                

                string signal_name_list[] = {"EBB_BrkPedalAppliedSt","EBB_BrkPedalApplied","EBB_BrkPedPst","EBB_2_A_MsgCounter","EBB_BrkFxCpb","EBB_BrkLightReq","EBB_BrkPedPstVD","EBB_2_A_Checksum"};

                int bit_index[] = {30, 2, 29, 1, 32, 8, 44, 4, 42, 2, 41, 1, 40, 1, 56, 8};

                double signal_factor[] = {1.0, 1.0, 0.392, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.EBB_BrkPedalAppliedSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.EBB_BrkPedalApplied = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.EBB_BrkPedPst = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.EBB_2_A_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.EBB_BrkFxCpb = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.EBB_BrkLightReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.EBB_BrkPedPstVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.EBB_2_A_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x282):{

                miliwave_msg::EBB_1_A radar_list_;

                

                string signal_name_list[] = {"EBB_ActOutputRodTravel","EBB_ActOutputRodTravelSt","EBB_1_A_MsgCounter","EBB_1_A_Checksum"};

                int bit_index[] = {16, 12, 26, 2, 36, 4, 56, 8};

                double signal_factor[] = {0.015625, 1.0, 1.0, 1.0};

                double signal_offset[] = {-5.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.EBB_ActOutputRodTravel = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.EBB_ActOutputRodTravelSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.EBB_1_A_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.EBB_1_A_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x3c7):{

                miliwave_msg::DMS_1 radar_list_;

                

                string signal_name_list[] = {"DMS_SysErrSt","DMS_InterestsRegion","DMS_DrvrDetSts","DMS_L3DriverFatigueSt","DMS_L3DriverDistractionSt","DMS_1_MsgCounter","DMS_1_Checksum"};

                int bit_index[] = {2, 3, 19, 5, 16, 3, 36, 12, 42, 6, 48, 4, 56, 8};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.DMS_SysErrSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.DMS_InterestsRegion = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.DMS_DrvrDetSts = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.DMS_L3DriverFatigueSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.DMS_L3DriverDistractionSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.DMS_1_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.DMS_1_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x39a):{

                miliwave_msg::BCS_EPB_2_A radar_list_;

                

                string signal_name_list[] = {"BCS_EPB_2_A_MsgCounter","EPB_AchievedClampForce","BCS_EPB_2_A_Checksum"};

                int bit_index[] = {20, 4, 32, 5, 56, 8};

                double signal_factor[] = {1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.BCS_EPB_2_A_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.EPB_AchievedClampForce = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.BCS_EPB_2_A_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x397):{

                miliwave_msg::BCS_EPB_1_A radar_list_;

                

                string signal_name_list[] = {"EPB_SwitchStVD","EPB_SwitchSt","EPB_SysSt","EPB_FailSt","BCS_EPB_1_A_MsgCounter","BCS_EPB_1_A_Checksum"};

                int bit_index[] = {2, 1, 0, 2, 8, 3, 55, 1, 48, 4, 56, 8};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.EPB_SwitchStVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.EPB_SwitchSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.EPB_SysSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.EPB_FailSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.BCS_EPB_1_A_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.BCS_EPB_1_A_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x26a):{

                miliwave_msg::BCS_11_A radar_list_;

                

                string signal_name_list[] = {"BCS_ActVehLongAccel","BCS_VehLongAccelOffset","BCS_ActVehLaltrlAccel","BCS_VehLaltrlAccelOffset","BCS_VDCOff","BCS_TCSOff","BCS_ActVehLaltrlAccelVD","BCS_ActVehLongAccelVD","BCS_11_A_MsgCounter","BCS_11_A_Checksum"};

                int bit_index[] = {12, 12, 16, 12, 36, 12, 40, 12, 55, 1, 54, 1, 53, 1, 52, 1, 48, 4, 56, 8};

                double signal_factor[] = {0.027126736, 0.027126736, 0.027126736, 0.027126736, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {-21.593, -21.593, -21.593, -21.593, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.BCS_ActVehLongAccel = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.BCS_VehLongAccelOffset = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.BCS_ActVehLaltrlAccel = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.BCS_VehLaltrlAccelOffset = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.BCS_VDCOff = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.BCS_TCSOff = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.BCS_ActVehLaltrlAccelVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.BCS_ActVehLongAccelVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.BCS_11_A_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.BCS_11_A_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x26d):{

                miliwave_msg::BCS_10_A radar_list_;

                

                string signal_name_list[] = {"BCS_RLWheelRotatedDirectionVD","BCS_RLWheelRotatedDirection","BCS_RLWheelSpdVD","BCS_RLWheelSpd","BCS_RRWheelSpdVD","BCS_RRWheelRotatedDirection","BCS_RRWheelRotatedDirectionVD","BCS_RRWheelSpd","BCS_10_A_MsgCounter","BCS_10_A_Checksum"};

                int bit_index[] = {7, 1, 6, 1, 5, 1, 16, 13, 31, 1, 30, 1, 29, 1, 32, 13, 48, 4, 56, 8};

                double signal_factor[] = {1.0, 1.0, 1.0, 0.05625, 1.0, 1.0, 1.0, 0.05625, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.BCS_RLWheelRotatedDirectionVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.BCS_RLWheelRotatedDirection = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.BCS_RLWheelSpdVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.BCS_RLWheelSpd = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.BCS_RRWheelSpdVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.BCS_RRWheelRotatedDirection = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.BCS_RRWheelRotatedDirectionVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.BCS_RRWheelSpd = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.BCS_10_A_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.BCS_10_A_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x26c):{

                miliwave_msg::BCS_9_A radar_list_;

                

                string signal_name_list[] = {"BCS_FLWheelRotatedDirectionVD","BCS_FLWheelRotatedDirection","BCS_FLWheelSpdVD","BCS_FLWheelSpd","BCS_FRWheelSpdVD","BCS_FRWheelRotatedDirection","BCS_FRWheelRotatedDirectionVD","BCS_FRWheelSpd","BCS_9_A_MsgCounter","BCS_9_A_Checksum"};

                int bit_index[] = {7, 1, 6, 1, 5, 1, 16, 13, 31, 1, 30, 1, 29, 1, 32, 13, 48, 4, 56, 8};

                double signal_factor[] = {1.0, 1.0, 1.0, 0.05625, 1.0, 1.0, 1.0, 0.05625, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.BCS_FLWheelRotatedDirectionVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.BCS_FLWheelRotatedDirection = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.BCS_FLWheelSpdVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.BCS_FLWheelSpd = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.BCS_FRWheelSpdVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.BCS_FRWheelRotatedDirection = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.BCS_FRWheelRotatedDirectionVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.BCS_FRWheelSpd = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.BCS_9_A_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.BCS_9_A_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x28c):{

                miliwave_msg::BCS_8_A radar_list_;

                

                string signal_name_list[] = {"BCS_MasterCylinderPrOffsetVD","BCS_MasterCylinderPrVD","BCS_BrakeOverHeat","BCS_NoBrakeForce","BCS_MasterCylinderPr","BCS_8_A_MsgCounter","BCS_ABAavailable","BCS_ABAactive","BCS_MasterCylinderPrOffset","BCS_CDDAvailable","BCS_CDDActive","BCS_AWBAvailable","BCS_AWBActive","BCS_AEBAvailable","BCS_AEBActive","BCS_ABPAvailable","BCS_ABPActive","BCS_CDDFail","BCS_VehicleStandStillSt","BCS_QDCACC","BCS_8_A_Checksum"};

                int bit_index[] = {7, 1, 6, 1, 5, 1, 4, 1, 8, 12, 20, 4, 19, 1, 18, 1, 24, 10, 39, 1, 38, 1, 37, 1, 36, 1, 35, 1, 34, 1, 33, 1, 32, 1, 47, 1, 41, 2, 48, 2, 56, 8};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 0.1, 1.0, 1.0, 1.0, 0.1, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -15.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.BCS_MasterCylinderPrOffsetVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.BCS_MasterCylinderPrVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.BCS_BrakeOverHeat = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.BCS_NoBrakeForce = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.BCS_MasterCylinderPr = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.BCS_8_A_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.BCS_ABAavailable = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.BCS_ABAactive = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.BCS_MasterCylinderPrOffset = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.BCS_CDDAvailable = value_list[i] * factor + offset;
                    }
                 
                    if (i == 10){
                        radar_list_.BCS_CDDActive = value_list[i] * factor + offset;
                    }
                 
                    if (i == 11){
                        radar_list_.BCS_AWBAvailable = value_list[i] * factor + offset;
                    }
                 
                    if (i == 12){
                        radar_list_.BCS_AWBActive = value_list[i] * factor + offset;
                    }
                 
                    if (i == 13){
                        radar_list_.BCS_AEBAvailable = value_list[i] * factor + offset;
                    }
                 
                    if (i == 14){
                        radar_list_.BCS_AEBActive = value_list[i] * factor + offset;
                    }
                 
                    if (i == 15){
                        radar_list_.BCS_ABPAvailable = value_list[i] * factor + offset;
                    }
                 
                    if (i == 16){
                        radar_list_.BCS_ABPActive = value_list[i] * factor + offset;
                    }
                 
                    if (i == 17){
                        radar_list_.BCS_CDDFail = value_list[i] * factor + offset;
                    }
                 
                    if (i == 18){
                        radar_list_.BCS_VehicleStandStillSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 19){
                        radar_list_.BCS_QDCACC = value_list[i] * factor + offset;
                    }
                 
                    if (i == 20){
                        radar_list_.BCS_8_A_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x294):{

                miliwave_msg::BCS_7_A radar_list_;

                

                string signal_name_list[] = {"BCS_HDCErrSt","BCS_HDCCtrlSt","BCS_7_A_MsgCounter","BCS_7_A_Checksum"};

                int bit_index[] = {22, 1, 19, 2, 27, 4, 56, 8};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.BCS_HDCErrSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.BCS_HDCCtrlSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.BCS_7_A_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.BCS_7_A_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x3b6):{

                miliwave_msg::BCS_6_A radar_list_;

                

                string signal_name_list[] = {"BCS_YawRateSt","BCS_YawRate","BCS_6_A_MsgCounter","BCS_YawRateOffset","BCS_6_A_Checksum"};

                int bit_index[] = {4, 1, 8, 12, 20, 4, 24, 12, 56, 8};

                double signal_factor[] = {1.0, 0.0009765625, 1.0, 0.0009765625, 1.0};

                double signal_offset[] = {0.0, -2.0943, 0.0, -0.13, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.BCS_YawRateSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.BCS_YawRate = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.BCS_6_A_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.BCS_YawRateOffset = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.BCS_6_A_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x36c):{

                miliwave_msg::BCS_5_A radar_list_;

                

                string signal_name_list[] = {"BCS_FLWheelSpdEdgesSum","BCS_FRWheelSpdEdgesSum","BCS_RLWheelSpdEdgesSum","BCS_RRWheelSpdEdgesSum","BCS_5_A_MsgCounter","BCS_RRWheelSpdEdgesSumVD","BCS_RLWheelSpdEdgesSumVD","BCS_FRWheelSpdEdgesSumVD","BCS_FLWheelSpdEdgesSumVD","BCS_5_A_Checksum"};

                int bit_index[] = {12, 12, 16, 12, 36, 12, 40, 12, 52, 4, 51, 1, 50, 1, 49, 1, 48, 1, 56, 8};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.BCS_FLWheelSpdEdgesSum = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.BCS_FRWheelSpdEdgesSum = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.BCS_RLWheelSpdEdgesSum = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.BCS_RRWheelSpdEdgesSum = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.BCS_5_A_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.BCS_RRWheelSpdEdgesSumVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.BCS_RLWheelSpdEdgesSumVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.BCS_FRWheelSpdEdgesSumVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.BCS_FLWheelSpdEdgesSumVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.BCS_5_A_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x268):{

                miliwave_msg::BCS_3_A radar_list_;

                

                string signal_name_list[] = {"BCS_TargetRecpTorqRqSt","BCS_TargetRecpTorqRq"};

                int bit_index[] = {2, 2, 24, 16};

                double signal_factor[] = {1.0, 1.0};

                double signal_offset[] = {0.0, -32767.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.BCS_TargetRecpTorqRqSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.BCS_TargetRecpTorqRq = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x260):{

                miliwave_msg::BCS_2_A radar_list_;

                

                string signal_name_list[] = {"BCS_VDCFaultSt","BCS_TCSActiveSt","BCS_TCSFaultSt","BCS_EBDActiveSt","BCS_EBDFaultSt","BCS_ABSFaultSt","BCS_ABSActiveSt","BCS_EngTorqDecActiveSt","BCS_VehSpdVD","BCS_VehSpd","BCS_VDCActiveSt","BCS_EngTorqIncActiveSt","BCS_2_A_MsgCounter","BCS_2_A_Checksum"};

                int bit_index[] = {7, 1, 6, 1, 5, 1, 4, 1, 3, 1, 2, 1, 1, 1, 38, 1, 37, 1, 40, 13, 53, 1, 52, 1, 48, 4, 56, 8};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.05625, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.BCS_VDCFaultSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.BCS_TCSActiveSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.BCS_TCSFaultSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.BCS_EBDActiveSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.BCS_EBDFaultSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.BCS_ABSFaultSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.BCS_ABSActiveSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.BCS_EngTorqDecActiveSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.BCS_VehSpdVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.BCS_VehSpd = value_list[i] * factor + offset;
                    }
                 
                    if (i == 10){
                        radar_list_.BCS_VDCActiveSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 11){
                        radar_list_.BCS_EngTorqIncActiveSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 12){
                        radar_list_.BCS_2_A_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 13){
                        radar_list_.BCS_2_A_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x3db):{

                miliwave_msg::BSDS_1 radar_list_;

                

                string signal_name_list[] = {"BSDS_LCAWarnLeft","BSDS_TargetRelSpdL","BSDS_TargetLVD","BSDS_TargetDstL"};

                int bit_index[] = {28, 2, 34, 10, 32, 2, 53, 11};

                double signal_factor[] = {1.0, 0.06225, 1.0, 0.06225};

                double signal_offset[] = {0.0, -10.0, 0.0, -90.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.BSDS_LCAWarnLeft = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.BSDS_TargetRelSpdL = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.BSDS_TargetLVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.BSDS_TargetDstL = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x3a4):{

                miliwave_msg::BSDM_1 radar_list_;

                

                string signal_name_list[] = {"BSDM_LCAWarnRight","BSDM_TargetRelSpdR","BSDM_TargetDstR","BSDM_TargetRVD"};

                int bit_index[] = {24, 2, 44, 10, 49, 11, 62, 2};

                double signal_factor[] = {1.0, 0.06225, 0.06225, 1.0};

                double signal_offset[] = {0.0, -10.0, -90.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.BSDM_LCAWarnRight = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.BSDM_TargetRelSpdR = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.BSDM_TargetDstR = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.BSDM_TargetRVD = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x3ab):{

                miliwave_msg::GW_SRS_2_A radar_list_;

                

                string signal_name_list[] = {"SRS_DriverSeatBeltSt","SRS_PsngrSeatBeltSt","SRS_2_MsgCounter","SRS_2_Checksum"};

                int bit_index[] = {2, 2, 0, 2, 48, 4, 56, 8};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.SRS_DriverSeatBeltSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.SRS_PsngrSeatBeltSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.SRS_2_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.SRS_2_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x1ae):{

                miliwave_msg::GW_SRS_1_A radar_list_;

                

                string signal_name_list[] = {"SRS_CrashOutputSt"};

                int bit_index[] = {0, 8};

                double signal_factor[] = {1.0};

                double signal_offset[] = {0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.SRS_CrashOutputSt = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x3ac):{

                miliwave_msg::GW_ICM_HVAC_A radar_list_;

                

                string signal_name_list[] = {"HVAC_CorrectedExterTempVD","HVAC_CorrectedExterTemp","ICM_TotalOdometer","ICM_QDashACCFail","ICM_DisFail","ICM_VehInsSpd"};

                int bit_index[] = {3, 1, 8, 8, 40, 20, 53, 2, 52, 1, 56, 8};

                double signal_factor[] = {1.0, 0.5, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, -40.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.HVAC_CorrectedExterTempVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.HVAC_CorrectedExterTemp = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.ICM_TotalOdometer = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.ICM_QDashACCFail = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.ICM_DisFail = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.ICM_VehInsSpd = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x296):{

                miliwave_msg::GW_ICM_1_A radar_list_;

                

                string signal_name_list[] = {"ICM_MFSButtonSt","ICM_SetIACCSt"};

                int bit_index[] = {19, 4, 47, 1};

                double signal_factor[] = {1.0, 1.0};

                double signal_offset[] = {0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.ICM_MFSButtonSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.ICM_SetIACCSt = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x2fa):{

                miliwave_msg::GW_HOD_1_A radar_list_;

                

                string signal_name_list[] = {"HOD_CalibrationSt","HOD_ApRestStatus","HOD_TouchZone3","HOD_TouchZone2","HOD_TouchZone1","HOD_VBattOORFault","HOD_FaultStatus","HOD_LINComFault","GW_HOD_1_MsgCounter","GW_HOD_1_Checksum"};

                int bit_index[] = {7, 1, 6, 1, 2, 1, 1, 1, 0, 1, 14, 1, 13, 1, 12, 1, 8, 4, 24, 8};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.HOD_CalibrationSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.HOD_ApRestStatus = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.HOD_TouchZone3 = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.HOD_TouchZone2 = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.HOD_TouchZone1 = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.HOD_VBattOORFault = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.HOD_FaultStatus = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.HOD_LINComFault = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.GW_HOD_1_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.GW_HOD_1_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x61f):{

                miliwave_msg::GW_BCM_RLS_1_B_A radar_list_;

                

                string signal_name_list[] = {"RLS_RainfallLevel","RLS_AMBBrightness"};

                int bit_index[] = {20, 4, 40, 11};

                double signal_factor[] = {1.0, 20.0};

                double signal_offset[] = {0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.RLS_RainfallLevel = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.RLS_AMBBrightness = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x375):{

                miliwave_msg::GW_BCM_2_A radar_list_;

                

                string signal_name_list[] = {"BCM_FrontWiperSt","BCM_RearFogLampSt","BCM_FrontFogLampSt","BCM_HighBeamSt","BCM_LowBeamSt","BCM_DriverDoorAjarSt","BCM_KeySt","BCM_FrontWasherSt","BCM_RRDoorAjarSt","BCM_RLDoorAjarSt","BCM_PsngrDoorAjarSt","BCM_TurnLightSwitchSt","BCM_RightTurnLampFaultSt","BCM_RightTurnLampSt","BCM_LeftTurnLampFaultSt","BCM_LeftTurnLampSt","BCM_MainLampSWSt","BCM_BeamSwitchSt","BCM_AutoLightCtrlSt","BCM_ATWS_St","BCM_PsngrDoorLockSt","BCM_DriverDoorLockSt","BCM_BCAN_2_MsgCounter","BCM_BCAN_2_Checksum"};

                int bit_index[] = {4, 2, 3, 1, 2, 1, 1, 1, 0, 1, 14, 1, 8, 2, 22, 1, 19, 1, 18, 1, 17, 1, 26, 2, 36, 1, 35, 1, 34, 1, 33, 1, 46, 2, 44, 2, 43, 1, 40, 3, 53, 1, 52, 1, 48, 4, 56, 8};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.BCM_FrontWiperSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.BCM_RearFogLampSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.BCM_FrontFogLampSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.BCM_HighBeamSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.BCM_LowBeamSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.BCM_DriverDoorAjarSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.BCM_KeySt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.BCM_FrontWasherSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.BCM_RRDoorAjarSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.BCM_RLDoorAjarSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 10){
                        radar_list_.BCM_PsngrDoorAjarSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 11){
                        radar_list_.BCM_TurnLightSwitchSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 12){
                        radar_list_.BCM_RightTurnLampFaultSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 13){
                        radar_list_.BCM_RightTurnLampSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 14){
                        radar_list_.BCM_LeftTurnLampFaultSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 15){
                        radar_list_.BCM_LeftTurnLampSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 16){
                        radar_list_.BCM_MainLampSWSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 17){
                        radar_list_.BCM_BeamSwitchSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 18){
                        radar_list_.BCM_AutoLightCtrlSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 19){
                        radar_list_.BCM_ATWS_St = value_list[i] * factor + offset;
                    }
                 
                    if (i == 20){
                        radar_list_.BCM_PsngrDoorLockSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 21){
                        radar_list_.BCM_DriverDoorLockSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 22){
                        radar_list_.BCM_BCAN_2_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 23){
                        radar_list_.BCM_BCAN_2_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x392):{

                miliwave_msg::GW_BCM_1_A radar_list_;

                

                string signal_name_list[] = {"TPMS_TyreSt","BCM_HazardLampSt"};

                int bit_index[] = {4, 1, 0, 1};

                double signal_factor[] = {1.0, 1.0};

                double signal_offset[] = {0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.TPMS_TyreSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.BCM_HazardLampSt = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x32e):{

                miliwave_msg::GW_ACU_10_A_A radar_list_;

                

                string signal_name_list[] = {"ACU_IFC_SpeedLimit","ACU_IFC_ISDRestOfdis","ACU_IFC_OfframpDis","ACU_IFC_SpeedLimtType","ACU_IFC_RoadType","ACU_IFC_ZoneCode","ACU_IFC_NaviSt","ACU_IFC_NaviCorp","ACU_IFC_NaviNewIconDis","ACU_IFC_NaviNewIcon","ACU_IFC_SpeedLimitUnit","ACU_IFC_OfframpSt","ACU_NDASDMapReadySt","ACU_IFC_SLCAheadDis"};

                int bit_index[] = {0, 8, 8, 8, 16, 8, 28, 4, 24, 4, 37, 3, 35, 2, 32, 3, 40, 8, 52, 4, 50, 2, 49, 1, 48, 1, 56, 8};

                double signal_factor[] = {1.0, 1.0, 0.02, 1.0, 1.0, 1.0, 1.0, 1.0, 0.02, 1.0, 1.0, 1.0, 1.0, 5.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.ACU_IFC_SpeedLimit = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.ACU_IFC_ISDRestOfdis = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.ACU_IFC_OfframpDis = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.ACU_IFC_SpeedLimtType = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.ACU_IFC_RoadType = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.ACU_IFC_ZoneCode = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.ACU_IFC_NaviSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.ACU_IFC_NaviCorp = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.ACU_IFC_NaviNewIconDis = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.ACU_IFC_NaviNewIcon = value_list[i] * factor + offset;
                    }
                 
                    if (i == 10){
                        radar_list_.ACU_IFC_SpeedLimitUnit = value_list[i] * factor + offset;
                    }
                 
                    if (i == 11){
                        radar_list_.ACU_IFC_OfframpSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 12){
                        radar_list_.ACU_NDASDMapReadySt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 13){
                        radar_list_.ACU_IFC_SLCAheadDis = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x83):{

                miliwave_msg::GW_ACU_3_A_A radar_list_;

                

                string signal_name_list[] = {"ACU_ELKCfg","ACU_FCTA_TypeReqCfg","ACU_RCTA_TypeReqCfg","ACU_RAWCfg","ACU_FCTACfg","ACU_ADASWarnTypeSwitch","ACU_NDALCStySwitchReq","ACU_NDALCConSwitchReq","ACU_NDASwitchReq"};

                int bit_index[] = {22, 2, 30, 2, 28, 2, 26, 2, 24, 2, 62, 2, 60, 2, 58, 2, 56, 2};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.ACU_ELKCfg = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.ACU_FCTA_TypeReqCfg = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.ACU_RCTA_TypeReqCfg = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.ACU_RAWCfg = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.ACU_FCTACfg = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.ACU_ADASWarnTypeSwitch = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.ACU_NDALCStySwitchReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.ACU_NDALCConSwitchReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.ACU_NDASwitchReq = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x82):{

                miliwave_msg::GW_ACU_2_A_A radar_list_;

                

                string signal_name_list[] = {"ACU_LDW_LKACfg","ACU_HMA_SwitchReq","ACU_TSR_SwitchReq","ACU_LKS_TypeReq","ACU_iACC_SwitchReq","ACU_DOWCfg","ACU_RCTACfg","ACU_BSDCfg","ACU_TSR_AudioWarnReq","ACU_HWA_SwitchReq","ACU_HWAHFCfg"};

                int bit_index[] = {0, 2, 14, 2, 12, 2, 16, 2, 46, 2, 44, 2, 42, 2, 40, 2, 49, 2, 62, 2, 56, 2};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.ACU_LDW_LKACfg = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.ACU_HMA_SwitchReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.ACU_TSR_SwitchReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.ACU_LKS_TypeReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.ACU_iACC_SwitchReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.ACU_DOWCfg = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.ACU_RCTACfg = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.ACU_BSDCfg = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.ACU_TSR_AudioWarnReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.ACU_HWA_SwitchReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 10){
                        radar_list_.ACU_HWAHFCfg = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x3c5):{

                miliwave_msg::GW_ACU_11_A radar_list_;

                

                string signal_name_list[] = {"ACU_Longitude","ACU_Latitude"};

                int bit_index[] = {28, 28, 48, 28};

                double signal_factor[] = {1e-05, 1e-05};

                double signal_offset[] = {0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.ACU_Longitude = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.ACU_Latitude = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x35a):{

                miliwave_msg::GW_ACU_10_A radar_list_;

                

                string signal_name_list[] = {"ACU_Time_Year","ACU_Time_Month","ACU_Time_Day","ACU_Time_Hour","ACU_Time_Min","ACU_Time_Sec","ACU_LanguageTypeSet"};

                int bit_index[] = {0, 8, 12, 4, 8, 5, 18, 5, 28, 6, 38, 6, 32, 6};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {2000.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.ACU_Time_Year = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.ACU_Time_Month = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.ACU_Time_Day = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.ACU_Time_Hour = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.ACU_Time_Min = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.ACU_Time_Sec = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.ACU_LanguageTypeSet = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x81):{

                miliwave_msg::GW_ACU_2_A radar_list_;

                

                string signal_name_list[] = {"ACU_AEBOff","ACU_FCWOff","ACU_FCWWarnDistanceCfg"};

                int bit_index[] = {20, 2, 18, 2, 16, 2};

                double signal_factor[] = {1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.ACU_AEBOff = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.ACU_FCWOff = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.ACU_FCWWarnDistanceCfg = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x78e):{

                miliwave_msg::ADAS_Diag_Tx radar_list_;

                

                string signal_name_list[] = {"ADAS_Diag_Response"};

                int bit_index[] = {56, 64};

                double signal_factor[] = {1.0};

                double signal_offset[] = {0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.ADAS_Diag_Response = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x37b):{

                miliwave_msg::IFC_5 radar_list_;

                

                string signal_name_list[] = {"IFC_TJASPPCoeffA0","IFC_TJASPPCoeffA1","IFC_TJASPPCoeffA2","IFC_TJASPPCoeffA3","IFC_TJASPPInfo1SPType","IFC_TJASPPInfo1SPconf","IFC_TJASPPInfo1SPMaxRange"};

                int bit_index[] = {13, 11, 18, 11, 24, 11, 44, 11, 40, 4, 50, 6, 58, 8};

                double signal_factor[] = {0.01, 0.001, 1e-05, 1e-07, 1.0, 2.0, 1.0};

                double signal_offset[] = {-10.23, -1.023, -0.01023, -0.0001023, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.IFC_TJASPPCoeffA0 = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.IFC_TJASPPCoeffA1 = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.IFC_TJASPPCoeffA2 = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.IFC_TJASPPCoeffA3 = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.IFC_TJASPPInfo1SPType = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.IFC_TJASPPInfo1SPconf = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.IFC_TJASPPInfo1SPMaxRange = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x37a):{

                miliwave_msg::IFC_4 radar_list_;

                

                string signal_name_list[] = {"IFC_AEBCustoSetting","IFC_AEBSteeringInhibit","IFC_AEBAccelePedalOverRide","IFC_AEBBrePedalPressure","IFC_AEBBrkPedalOverRide","IFC_AEBTarLatPos","IFC_AEBTarRangeRate","IFC_AEBTarLongPos","IFC_AEBTarMotionState","IFC_AEBTarCalss","IFC_AEBTarLatSpd","IFC_AEBTarConfiLevel","IFC_HostAEBFeatureDia","IFC_AEBTarDetSensor","IFC_AEBTarRangeAccel"};

                int bit_index[] = {5, 3, 4, 1, 3, 1, 2, 1, 1, 1, -8, 9, 30, 10, 37, 9, 35, 2, 32, 3, 40, 8, 53, 3, 51, 2, 49, 2, 40, 9};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 0.2, 0.1, 0.2, 1.0, 1.0, 0.2, 1.0, 1.0, 1.0, 0.1};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, -51.0, -51.0, 0.0, 0.0, 0.0, -25.0, 0.0, 0.0, 0.0, -25.5};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.IFC_AEBCustoSetting = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.IFC_AEBSteeringInhibit = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.IFC_AEBAccelePedalOverRide = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.IFC_AEBBrePedalPressure = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.IFC_AEBBrkPedalOverRide = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.IFC_AEBTarLatPos = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.IFC_AEBTarRangeRate = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.IFC_AEBTarLongPos = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.IFC_AEBTarMotionState = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.IFC_AEBTarCalss = value_list[i] * factor + offset;
                    }
                 
                    if (i == 10){
                        radar_list_.IFC_AEBTarLatSpd = value_list[i] * factor + offset;
                    }
                 
                    if (i == 11){
                        radar_list_.IFC_AEBTarConfiLevel = value_list[i] * factor + offset;
                    }
                 
                    if (i == 12){
                        radar_list_.IFC_HostAEBFeatureDia = value_list[i] * factor + offset;
                    }
                 
                    if (i == 13){
                        radar_list_.IFC_AEBTarDetSensor = value_list[i] * factor + offset;
                    }
                 
                    if (i == 14){
                        radar_list_.IFC_AEBTarRangeAccel = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x2dc):{

                miliwave_msg::ADAS_FRR_1 radar_list_;

                

                string signal_name_list[] = {"ADAS_SafeStopLampWarn","FRR_FCTAWarnL","FRR_FCTAAssistType","FRR_FCTASt","FRR_ErrSt","ADAS_AutonomyLevel","FRR_FCTAWarnR"};

                int bit_index[] = {6, 2, 4, 2, 2, 2, 0, 2, 14, 2, 11, 3, 8, 2};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.ADAS_SafeStopLampWarn = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.FRR_FCTAWarnL = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.FRR_FCTAAssistType = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.FRR_FCTASt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.FRR_ErrSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.ADAS_AutonomyLevel = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.FRR_FCTAWarnR = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x23f):{

                miliwave_msg::ADAS_6_A radar_list_;

                

                string signal_name_list[] = {"ADAS_EDRTrigerReason","ADAS_NDALCStyleSt","ADAS_NDALCConfirmSt","ADAS_EDRTrigerFlag","ADAS_NDAEnableSt","ADAS_TrkTargt3DisColor","ADAS_TrkTargt2DisColor","ADAS_HWA_ILCWaitreasonLeft","ADAS_HWA_ILCWaitreasonRight","ADAS_VibIntensity","ADAS_SeatVibReq","ADAS_WarnTypeSt","ADAS_NDAOutputinfo","ADAS_NDASt","ADAS_TJASPPDispSt","ADAS_NRCLaneinfoReq","ADAS_HWAHF_EnableSt","ADAS_SPPMaxDisRange"};

                int bit_index[] = {4, 4, 2, 2, 0, 2, 15, 1, 14, 1, 12, 2, 10, 2, 16, 10, 38, 10, 36, 2, 34, 2, 32, 2, 43, 5, 40, 3, 54, 2, 53, 1, 51, 1, 56, 8};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.ADAS_EDRTrigerReason = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.ADAS_NDALCStyleSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.ADAS_NDALCConfirmSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.ADAS_EDRTrigerFlag = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.ADAS_NDAEnableSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.ADAS_TrkTargt3DisColor = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.ADAS_TrkTargt2DisColor = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.ADAS_HWA_ILCWaitreasonLeft = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.ADAS_HWA_ILCWaitreasonRight = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.ADAS_VibIntensity = value_list[i] * factor + offset;
                    }
                 
                    if (i == 10){
                        radar_list_.ADAS_SeatVibReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 11){
                        radar_list_.ADAS_WarnTypeSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 12){
                        radar_list_.ADAS_NDAOutputinfo = value_list[i] * factor + offset;
                    }
                 
                    if (i == 13){
                        radar_list_.ADAS_NDASt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 14){
                        radar_list_.ADAS_TJASPPDispSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 15){
                        radar_list_.ADAS_NRCLaneinfoReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 16){
                        radar_list_.ADAS_HWAHF_EnableSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 17){
                        radar_list_.ADAS_SPPMaxDisRange = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x3e2):{

                miliwave_msg::ADAS_5_A radar_list_;

                

                string signal_name_list[] = {"ADAS_5_Checksum","ADAS_HWAHF_EyesOnRoadReq","ADAS_HWAHF_EyesOnRoadSoundWarn","ADAS_HWAHF_TakeOverReq","ADAS_HWAHF_TakeOverReqSoundWarn","ADAS_HWAHF_Lightbar","ADAS_HWAHF_HandsOnReqSoundWarn","ADAS_HWAHF_LegalDisclaimer","ADAS_AdjRLnMrkingDispSt","IFC_ELKWarnR","IFC_ELKWarnL","IFC_ELKSt","ADAS_HWAHF_HandsOnPrompt","ADAS_TrkTargt3St","ADAS_TrkTargt3ObjClass","ADAS_TrkTargt3longPos","ADAS_TrkTargt3latPos","ADAS_HWAHF_SafeStop","ADAS_HWAHF_SafeStopSoundWarn","ADAS_5_MsgCounter"};

                int bit_index[] = {0, 8, 14, 2, 12, 2, 10, 2, 8, 2, 22, 2, 20, 2, 18, 2, 16, 2, 29, 3, 26, 3, 24, 2, 37, 3, 36, 1, 32, 4, 40, 8, 62, 10, 61, 1, 60, 1, 56, 4};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.1, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -51.2, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.ADAS_5_Checksum = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.ADAS_HWAHF_EyesOnRoadReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.ADAS_HWAHF_EyesOnRoadSoundWarn = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.ADAS_HWAHF_TakeOverReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.ADAS_HWAHF_TakeOverReqSoundWarn = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.ADAS_HWAHF_Lightbar = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.ADAS_HWAHF_HandsOnReqSoundWarn = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.ADAS_HWAHF_LegalDisclaimer = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.ADAS_AdjRLnMrkingDispSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.IFC_ELKWarnR = value_list[i] * factor + offset;
                    }
                 
                    if (i == 10){
                        radar_list_.IFC_ELKWarnL = value_list[i] * factor + offset;
                    }
                 
                    if (i == 11){
                        radar_list_.IFC_ELKSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 12){
                        radar_list_.ADAS_HWAHF_HandsOnPrompt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 13){
                        radar_list_.ADAS_TrkTargt3St = value_list[i] * factor + offset;
                    }
                 
                    if (i == 14){
                        radar_list_.ADAS_TrkTargt3ObjClass = value_list[i] * factor + offset;
                    }
                 
                    if (i == 15){
                        radar_list_.ADAS_TrkTargt3longPos = value_list[i] * factor + offset;
                    }
                 
                    if (i == 16){
                        radar_list_.ADAS_TrkTargt3latPos = value_list[i] * factor + offset;
                    }
                 
                    if (i == 17){
                        radar_list_.ADAS_HWAHF_SafeStop = value_list[i] * factor + offset;
                    }
                 
                    if (i == 18){
                        radar_list_.ADAS_HWAHF_SafeStopSoundWarn = value_list[i] * factor + offset;
                    }
                 
                    if (i == 19){
                        radar_list_.ADAS_5_MsgCounter = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x3e1):{

                miliwave_msg::ADAS_4_A radar_list_;

                

                string signal_name_list[] = {"ADAS_LnMarkingHeadAngToVeh","ADAS_LnMarkingCurvature","ADAS_AdjLLnMrkingDispSt","ADAS_LLnMarkingDisPropToLnWidth","ADAS_HWAHF_PedestrainDet","ADAS_HWAHF_SpdDecRea","ADAS_TrkTargt2St","ADAS_TrkTargt2ObjClass","ADAS_TrkTargt2longPos","ADAS_TrkTargt2latPos","ADAS_HWAHF_CrrtCycLock","ADAS_HWAHF_FailureSt","ADAS_HWAHF_Voiceinfo"};

                int bit_index[] = {13, 11, 18, 11, 16, 2, 25, 7, 24, 1, 37, 3, 36, 1, 32, 4, 40, 8, 62, 10, 61, 1, 60, 1, 56, 4};

                double signal_factor[] = {0.001, 1e-05, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.1, 1.0, 1.0, 1.0};

                double signal_offset[] = {-1.023, -0.01023, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -51.2, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.ADAS_LnMarkingHeadAngToVeh = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.ADAS_LnMarkingCurvature = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.ADAS_AdjLLnMrkingDispSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.ADAS_LLnMarkingDisPropToLnWidth = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.ADAS_HWAHF_PedestrainDet = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.ADAS_HWAHF_SpdDecRea = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.ADAS_TrkTargt2St = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.ADAS_TrkTargt2ObjClass = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.ADAS_TrkTargt2longPos = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.ADAS_TrkTargt2latPos = value_list[i] * factor + offset;
                    }
                 
                    if (i == 10){
                        radar_list_.ADAS_HWAHF_CrrtCycLock = value_list[i] * factor + offset;
                    }
                 
                    if (i == 11){
                        radar_list_.ADAS_HWAHF_FailureSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 12){
                        radar_list_.ADAS_HWAHF_Voiceinfo = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x3e0):{

                miliwave_msg::ADAS_3_A radar_list_;

                

                string signal_name_list[] = {"ADAS_RLnMrkingPolyCoeffA0","ADAS_RLnMrkingPolyCoeffA1","ADAS_RlnMrkingDispSt","ADAS_RLnMrkingPolyCoeffA2","ADAS_TrkTargt1St","ADAS_TrkTargt1ObjClass","ADAS_TrkTargt1longPos","ADAS_TrkTargt1latPos","ADAS_RLnMarkingType","ADAS_TrkTargt1DisColor"};

                int bit_index[] = {13, 11, 18, 11, 16, 2, 37, 11, 36, 1, 32, 4, 40, 8, 62, 10, 58, 4, 56, 2};

                double signal_factor[] = {0.01, 0.001, 1.0, 1e-05, 1.0, 1.0, 1.0, 0.1, 1.0, 1.0};

                double signal_offset[] = {-10.23, -1.023, 0.0, -0.01023, 0.0, 0.0, 0.0, -51.2, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.ADAS_RLnMrkingPolyCoeffA0 = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.ADAS_RLnMrkingPolyCoeffA1 = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.ADAS_RlnMrkingDispSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.ADAS_RLnMrkingPolyCoeffA2 = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.ADAS_TrkTargt1St = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.ADAS_TrkTargt1ObjClass = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.ADAS_TrkTargt1longPos = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.ADAS_TrkTargt1latPos = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.ADAS_RLnMarkingType = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.ADAS_TrkTargt1DisColor = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x3df):{

                miliwave_msg::ADAS_2_A radar_list_;

                

                string signal_name_list[] = {"ADAS_LLnMrkingPolyCoeffA0","ADAS_LLnMrkingPolyCoeffA1","ADAS_LlnMrkingDispSt","ADAS_LLnMrkingPolyCoeffA2","ADAS_TrkTargt0St","ADAS_TrkTargt0ObjClass","ADAS_TrkTargt0longPos","ADAS_TrkTargt0latPos","ADAS_LLnMarkingType","ADAS_TrkTargt0DisColor"};

                int bit_index[] = {13, 11, 18, 11, 16, 2, 37, 11, 36, 1, 32, 4, 40, 8, 62, 10, 58, 4, 56, 2};

                double signal_factor[] = {0.01, 0.001, 1.0, 1e-05, 1.0, 1.0, 1.0, 0.1, 1.0, 1.0};

                double signal_offset[] = {-10.23, -1.023, 0.0, -0.01023, 0.0, 0.0, 0.0, -51.2, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.ADAS_LLnMrkingPolyCoeffA0 = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.ADAS_LLnMrkingPolyCoeffA1 = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.ADAS_LlnMrkingDispSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.ADAS_LLnMrkingPolyCoeffA2 = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.ADAS_TrkTargt0St = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.ADAS_TrkTargt0ObjClass = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.ADAS_TrkTargt0longPos = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.ADAS_TrkTargt0latPos = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.ADAS_LLnMarkingType = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.ADAS_TrkTargt0DisColor = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x3d8):{

                miliwave_msg::ADAS_1_A radar_list_;

                

                string signal_name_list[] = {"ADAS_SensorBlockedSts","ADAS_SensorCalibrationSts","ADAS_SensorFailure","ADAS_ILCRightZoneSearch","ADAS_ILCLeftZoneSearch","ADAS_HWA_FailureSt","ADAS_HWA_EnableSt","ADAS_LateralCtrlTyp","ADAS_HWA_ILCRighttSt","ADAS_HWA_ILCLeftSt","ADAS_HWA_ILCTextInfo","ADAS_HWA_ILCSoundWarn","ADAS_HWA_TurnLampReq","ADAS_HWA_ILCAbortReason","ADAS_1_A_MsgCounter","ADAS_1_A_CheckSum"};

                int bit_index[] = {0, 8, 8, 8, 16, 8, 30, 2, 28, 2, 27, 1, 26, 1, 24, 2, 36, 4, 32, 4, 44, 4, 42, 2, 40, 2, 52, 4, 48, 4, 56, 8};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.ADAS_SensorBlockedSts = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.ADAS_SensorCalibrationSts = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.ADAS_SensorFailure = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.ADAS_ILCRightZoneSearch = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.ADAS_ILCLeftZoneSearch = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.ADAS_HWA_FailureSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.ADAS_HWA_EnableSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.ADAS_LateralCtrlTyp = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.ADAS_HWA_ILCRighttSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.ADAS_HWA_ILCLeftSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 10){
                        radar_list_.ADAS_HWA_ILCTextInfo = value_list[i] * factor + offset;
                    }
                 
                    if (i == 11){
                        radar_list_.ADAS_HWA_ILCSoundWarn = value_list[i] * factor + offset;
                    }
                 
                    if (i == 12){
                        radar_list_.ADAS_HWA_TurnLampReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 13){
                        radar_list_.ADAS_HWA_ILCAbortReason = value_list[i] * factor + offset;
                    }
                 
                    if (i == 14){
                        radar_list_.ADAS_1_A_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 15){
                        radar_list_.ADAS_1_A_CheckSum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x187):{

                miliwave_msg::MRR_3 radar_list_;

                

                string signal_name_list[] = {"MRR_AEBTargetDecel","MRR_ABPReq","MRR_AWBReq","MRR_ABALevel","MRR_ABAReq","MRR_AEBLVehHoldReq","MRR_ACCReqQua","MRR_AEBDecelCtrlReq","MRR_AWBLevel","MRR_ACCUnableActivated","MRR_ActTrqReqVD","MRR_ActTrqReq","MRR_3_MsgCounter","MRR_3_Checksum"};

                int bit_index[] = {8, 16, 23, 1, 22, 1, 20, 2, 19, 1, 18, 1, 17, 1, 16, 1, 24, 4, 35, 5, 34, 1, 52, 14, 48, 4, 56, 8};

                double signal_factor[] = {0.0004882, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {-16.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -5000.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.MRR_AEBTargetDecel = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.MRR_ABPReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.MRR_AWBReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.MRR_ABALevel = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.MRR_ABAReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.MRR_AEBLVehHoldReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.MRR_ACCReqQua = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.MRR_AEBDecelCtrlReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.MRR_AWBLevel = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.MRR_ACCUnableActivated = value_list[i] * factor + offset;
                    }
                 
                    if (i == 10){
                        radar_list_.MRR_ActTrqReqVD = value_list[i] * factor + offset;
                    }
                 
                    if (i == 11){
                        radar_list_.MRR_ActTrqReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 12){
                        radar_list_.MRR_3_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 13){
                        radar_list_.MRR_3_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x186):{

                miliwave_msg::MRR_2 radar_list_;

                

                string signal_name_list[] = {"MRR_LongCtrlTargetAccel","ADAS_IntlCrusMode","ADAS_LongCtrlTypReqLong","ADAS_LongCtrlTypReqMode","MRR_ACCRecpDecel","MRR_IFC_PriCANAvailableSt","MRR_LongCtrlTargetAccelJerkMinValue","MRR_IFC_PriCANErrorSt","MRR_LongCtrTargetAccelJerkMaxnValue","MRR_ACCRecpDecelReq","MRR_LongCtrlShutdownReq","MRR_ACCMinBrakingReq","MRR_LongCtrlDriveOff","MRR_LongCtrlDecToStopReq","MRR_LongCtrlAccelCtrlReq","MRR_LongCtrlModeForBrkSys","MRR_2_MsgCounter","MRR_2_Checksum"};

                int bit_index[] = {0, 8, 13, 3, 10, 3, 8, 2, 16, 8, 31, 1, 24, 7, 39, 1, 32, 7, 46, 1, 44, 2, 43, 1, 42, 1, 40, 1, 55, 1, 52, 3, 48, 4, 56, 8};

                double signal_factor[] = {0.05, 1.0, 1.0, 1.0, 0.05, 1.0, 0.2, 1.0, 0.2, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {-5.0, 0.0, 0.0, 0.0, -5.0, 0.0, -20.0, 0.0, -5.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.MRR_LongCtrlTargetAccel = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.ADAS_IntlCrusMode = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.ADAS_LongCtrlTypReqLong = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.ADAS_LongCtrlTypReqMode = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.MRR_ACCRecpDecel = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.MRR_IFC_PriCANAvailableSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.MRR_LongCtrlTargetAccelJerkMinValue = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.MRR_IFC_PriCANErrorSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.MRR_LongCtrTargetAccelJerkMaxnValue = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.MRR_ACCRecpDecelReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 10){
                        radar_list_.MRR_LongCtrlShutdownReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 11){
                        radar_list_.MRR_ACCMinBrakingReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 12){
                        radar_list_.MRR_LongCtrlDriveOff = value_list[i] * factor + offset;
                    }
                 
                    if (i == 13){
                        radar_list_.MRR_LongCtrlDecToStopReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 14){
                        radar_list_.MRR_LongCtrlAccelCtrlReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 15){
                        radar_list_.MRR_LongCtrlModeForBrkSys = value_list[i] * factor + offset;
                    }
                 
                    if (i == 16){
                        radar_list_.MRR_2_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 17){
                        radar_list_.MRR_2_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x3a6):{

                miliwave_msg::MRR_1 radar_list_;

                

                string signal_name_list[] = {"MRR_ACCTextInfo","MRR_ACCMode","MRR_ObjectCapturedSt","MRR_ACCTakeOverReq","MRR_ACCFuncCancel","MRR_ACCGoNotifier","MRR_ACCActiveSt","MRR_ACCFaultSt","ADAS_ShifttoParkGearReq","MRR_TauGapSet","MRR_TargetDistanceSt","MRR_TargetSpd","MRR_AEB_PEDPFaultSt","MRR_FCWLatentWarn","MRR_FCWPreWarn","MRR_FCWInterventionSt","MRR_FCWFaultSt","MRR_FCWOffSt","MRR_ACCAutoResNotifier","MRR_ACCQuitSound","MRR_ISLACC_St","MRR_FCWWarmDistance","MRR_AEBInterventionSt","MRR_AEBOffSt","MRR_AEBFaultSt","MRR_PEBSObjType","MRR_1_MsgCounter","MRR_1_Checksum"};

                int bit_index[] = {3, 5, 0, 3, 15, 1, 14, 1, 12, 2, 11, 1, 10, 1, 8, 2, 23, 1, 20, 3, 17, 3, 8, 9, 39, 1, 37, 2, 35, 2, 34, 1, 33, 1, 32, 1, 47, 1, 46, 1, 45, 1, 43, 2, 42, 1, 41, 1, 40, 1, 52, 4, 48, 4, 56, 8};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.5, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.MRR_ACCTextInfo = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.MRR_ACCMode = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.MRR_ObjectCapturedSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.MRR_ACCTakeOverReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.MRR_ACCFuncCancel = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.MRR_ACCGoNotifier = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.MRR_ACCActiveSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.MRR_ACCFaultSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.ADAS_ShifttoParkGearReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.MRR_TauGapSet = value_list[i] * factor + offset;
                    }
                 
                    if (i == 10){
                        radar_list_.MRR_TargetDistanceSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 11){
                        radar_list_.MRR_TargetSpd = value_list[i] * factor + offset;
                    }
                 
                    if (i == 12){
                        radar_list_.MRR_AEB_PEDPFaultSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 13){
                        radar_list_.MRR_FCWLatentWarn = value_list[i] * factor + offset;
                    }
                 
                    if (i == 14){
                        radar_list_.MRR_FCWPreWarn = value_list[i] * factor + offset;
                    }
                 
                    if (i == 15){
                        radar_list_.MRR_FCWInterventionSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 16){
                        radar_list_.MRR_FCWFaultSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 17){
                        radar_list_.MRR_FCWOffSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 18){
                        radar_list_.MRR_ACCAutoResNotifier = value_list[i] * factor + offset;
                    }
                 
                    if (i == 19){
                        radar_list_.MRR_ACCQuitSound = value_list[i] * factor + offset;
                    }
                 
                    if (i == 20){
                        radar_list_.MRR_ISLACC_St = value_list[i] * factor + offset;
                    }
                 
                    if (i == 21){
                        radar_list_.MRR_FCWWarmDistance = value_list[i] * factor + offset;
                    }
                 
                    if (i == 22){
                        radar_list_.MRR_AEBInterventionSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 23){
                        radar_list_.MRR_AEBOffSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 24){
                        radar_list_.MRR_AEBFaultSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 25){
                        radar_list_.MRR_PEBSObjType = value_list[i] * factor + offset;
                    }
                 
                    if (i == 26){
                        radar_list_.MRR_1_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 27){
                        radar_list_.MRR_1_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x19c):{

                miliwave_msg::MRR_IFC_2 radar_list_;

                

                string signal_name_list[] = {"IFC_TorqueReqSt","IFC_TorqueReq","ADAS_RemoteDiagCode","MRR_IFC_2_MsgCounter","MRR_IFC_2_Checksum"};

                int bit_index[] = {3, 2, 8, 11, 52, 2, 48, 4, 56, 8};

                double signal_factor[] = {1.0, 0.01, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, -10.24, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.IFC_TorqueReqSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.IFC_TorqueReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.ADAS_RemoteDiagCode = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.MRR_IFC_2_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.MRR_IFC_2_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

            case (0x3a3):{

                miliwave_msg::MRR_IFC_1 radar_list_;

                

                string signal_name_list[] = {"IFC_LateralCtrlQuitWarn","IFC_CameraBlockageSt","IFC_SysCalibrationSt","IFC_TSR_SLCAheadDis","IFC_CruiseMode","IFC_TSR_SpdLimType","IFC_TSR_ISDRestOfDis","IFC_LKS_LaneAssistType","ADAS_SVMLaneMarkingReq","IFC_TSR_AudioWarnEnable","MRR_IFC_1_MsgCounter","IFC_LKS_TakeoverReq","IFC_RightTrackingSt","IFC_LeftTrackingSt","IFC_LKS_St","IFC_TSR_SpdLimit","IFC_HWAHF_HandsOnIcon","IFC_HMA_St","IFC_TSR_OperatingSt","IFC_TSR_SpdLimitUnit","IFC_TJA_ICA_St","IFC_TSR_AcousticWarn","IFC_TSR_VisualWarn","IFC_HMA_Enable","IFC_TSR_Enable","IFC_HMA_HighBeamReq","MRR_IFC_1_Checksum"};

                int bit_index[] = {7, 1, 6, 1, 4, 2, 0, 4, 14, 2, 12, 2, 8, 4, 22, 2, 21, 1, 20, 1, 16, 4, 31, 1, 29, 2, 27, 2, 24, 3, 35, 5, 32, 3, 45, 3, 42, 3, 40, 2, 53, 3, 52, 1, 51, 1, 50, 1, 49, 1, 48, 1, 56, 8};

                double signal_factor[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};

                double signal_offset[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};

                int index_list_length = sizeof(bit_index)/sizeof(bit_index[0]);
                vector<int> the_index_list;
                for(int index = 0;index < index_list_length;index+=2){
                    int byte_ = bit_index[index] / 8;
                    int length_ = bit_index[index+1] / 8;
                    int bit_ = bit_index[index+1] % 8;
                    int start_index;
                    int end_index;
                    end_index = (byte_ + 1) * 8-bit_index[index] % 8;
                    start_index = end_index - bit_index[index + 1];
                    the_index_list.push_back(start_index);
                    the_index_list.push_back(end_index);
                }
                int signal_name_list_length = sizeof(signal_name_list)/sizeof(signal_name_list[0]);
                vector<int> value_list;
                int message_data;
                for(int i = 0;i < index_list_length;i+=2){
                    vector<int> data;
                    for(int j = 0;j < 64;j++){
                        if(j>=(int)(the_index_list[i])){

                            if(j >=(int)(the_index_list[i+1])){
                                break;
                            }
                            data.push_back(value[j]);
                        }
                    }
                    int data_length = data.size();
                    if(data_length > 0){
                        int num = 0;
                        reverse(data.begin(),data.end());
                        for(int k = 0;k<data_length;k++){
                            int n = data[k];
                            num += (n * pow(2,k));
                        }
                        value_list.push_back(num);
                    }
                }
                for(int i = 0;i < signal_name_list_length;i++){
                    int factor = signal_factor[i];
                    int offset = signal_offset[i];
                 
                    if (i == 0){
                        radar_list_.IFC_LateralCtrlQuitWarn = value_list[i] * factor + offset;
                    }
                 
                    if (i == 1){
                        radar_list_.IFC_CameraBlockageSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 2){
                        radar_list_.IFC_SysCalibrationSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 3){
                        radar_list_.IFC_TSR_SLCAheadDis = value_list[i] * factor + offset;
                    }
                 
                    if (i == 4){
                        radar_list_.IFC_CruiseMode = value_list[i] * factor + offset;
                    }
                 
                    if (i == 5){
                        radar_list_.IFC_TSR_SpdLimType = value_list[i] * factor + offset;
                    }
                 
                    if (i == 6){
                        radar_list_.IFC_TSR_ISDRestOfDis = value_list[i] * factor + offset;
                    }
                 
                    if (i == 7){
                        radar_list_.IFC_LKS_LaneAssistType = value_list[i] * factor + offset;
                    }
                 
                    if (i == 8){
                        radar_list_.ADAS_SVMLaneMarkingReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 9){
                        radar_list_.IFC_TSR_AudioWarnEnable = value_list[i] * factor + offset;
                    }
                 
                    if (i == 10){
                        radar_list_.MRR_IFC_1_MsgCounter = value_list[i] * factor + offset;
                    }
                 
                    if (i == 11){
                        radar_list_.IFC_LKS_TakeoverReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 12){
                        radar_list_.IFC_RightTrackingSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 13){
                        radar_list_.IFC_LeftTrackingSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 14){
                        radar_list_.IFC_LKS_St = value_list[i] * factor + offset;
                    }
                 
                    if (i == 15){
                        radar_list_.IFC_TSR_SpdLimit = value_list[i] * factor + offset;
                    }
                 
                    if (i == 16){
                        radar_list_.IFC_HWAHF_HandsOnIcon = value_list[i] * factor + offset;
                    }
                 
                    if (i == 17){
                        radar_list_.IFC_HMA_St = value_list[i] * factor + offset;
                    }
                 
                    if (i == 18){
                        radar_list_.IFC_TSR_OperatingSt = value_list[i] * factor + offset;
                    }
                 
                    if (i == 19){
                        radar_list_.IFC_TSR_SpdLimitUnit = value_list[i] * factor + offset;
                    }
                 
                    if (i == 20){
                        radar_list_.IFC_TJA_ICA_St = value_list[i] * factor + offset;
                    }
                 
                    if (i == 21){
                        radar_list_.IFC_TSR_AcousticWarn = value_list[i] * factor + offset;
                    }
                 
                    if (i == 22){
                        radar_list_.IFC_TSR_VisualWarn = value_list[i] * factor + offset;
                    }
                 
                    if (i == 23){
                        radar_list_.IFC_HMA_Enable = value_list[i] * factor + offset;
                    }
                 
                    if (i == 24){
                        radar_list_.IFC_TSR_Enable = value_list[i] * factor + offset;
                    }
                 
                    if (i == 25){
                        radar_list_.IFC_HMA_HighBeamReq = value_list[i] * factor + offset;
                    }
                 
                    if (i == 26){
                        radar_list_.MRR_IFC_1_Checksum = value_list[i] * factor + offset;
                    }

                }
                std::cout << radar_list_ << std::endl;
                radar_list_pub_.publish(radar_list_);
                break;
            };

        }
    };
};
